package EP.MetricasContenido;

import Controladores.ControladorScore;
import SBD.CRUD.EuclidianaBD;
import EP.Web.Pagina;
import EP.Web.RelacionPaginas;
import Jama.Matrix;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* @class Euclidiana
* @author Mauricio Alvarez.
* @brief Esta clase representa la clase Euclidiana, correspondiente a una entidad principal (EP).
*/
public class Euclidiana
{

    /**
     *  @var private int id_pagina
     *  @brief identificador de la página en la BD.
    */
    private int id_pagina;
    /**
     *  @var private int id_relacion_pag
     *  @brief identificador de la página en la BD.
    */
    private int id_relacion_pag;
    /**
     *  @var private int id_pagina_objetivo
     *  @brief identificador del texto alrededor tomado como patrón.
    */
    private int id_pagina_objetivo;
    /**
     *  @var private String url_test
     *  @brief URL de la página a evaluar.
    */
    private String url_test;
    /**
     *  @var private String url_objetivo
     *  @brief URL de la página tomada como patrón.
    */
    private String url_objetivo;
    /**
     *  @var private String termino
     *  @brief Termino de la consulta.
    */
    private String termino;
    /**
     *  @var private double valor_se
     *  @brief Valor de la similitud euclidiana.
    */
    private double valor_se;
    /**
     *  @var private ControladorScore cscore
     *  @brief Variable global de tipo clase ControladorScore.
    */
    private ControladorScore cscore;
    /**
     *  @var private EuclidianaBD sebd
     *  @brief Variable global de tipo clase EuclidianaBD.
    */
    private EuclidianaBD sebd;


    //////////////////////////
    // CONSTRUCTOR
    //////////////////////////
    public Euclidiana()
    {
        cscore = new ControladorScore();
        sebd = new EuclidianaBD();
    }


    //////////////////////////
    // Getters & Setters
    //////////////////////////


    public int getId_pagina() {
        return id_pagina;
    }

    public void setId_pagina(int id_pagina) {
        this.id_pagina = id_pagina;
    }

    public String getTermino() {
        return termino;
    }

    public void setTermino(String termino) {
        this.termino = termino;
    }

    public String getUrl_objetivo() {
        return url_objetivo;
    }

    public void setUrl_objetivo(String url_objetivo) {
        this.url_objetivo = url_objetivo;
    }

    public double getValor_se() {
        return valor_se;
    }

    public void setValor_se(double valor_se) {
        this.valor_se = valor_se;
    }

    public int getId_pagina_objetivo() {
        return id_pagina_objetivo;
    }

    public void setId_pagina_objetivo(int id_pagina_objetivo) {
        this.id_pagina_objetivo = id_pagina_objetivo;
    }

    public int getId_relacion_pag() {
        return id_relacion_pag;
    }

    public void setId_relacion_pag(int id_relacion_pag) {
        this.id_relacion_pag = id_relacion_pag;
    }

    public String getUrl_test() {
        return url_test;
    }

    public void setUrl_test(String url_test) {
        this.url_test = url_test;
    }


    //////////////////////
    // OPERACIONES
    //////////////////////

    /**
     * @brief Realiza la operación matemática euclidiana usando la norma.
     * @param La matriz o vector patrón y la de prueba.
     * @return double
    */
    private double SimilaridadEuclidiana(Matrix targetMatrix, Matrix objetivoMatrix)
    {
        double RestaPesos = (targetMatrix.minus(objetivoMatrix)).normF();
        return RestaPesos;

    }//FIN SimilaridadEuclidiana (OK)


    /**
     * @brief Invoca el cálculo la similitud euclidiana usando la norma.
     * @param El listado de tópicos, los resultados de las métricas de ranking
     * (score), el listado de páginas, el listado de relaciones de páginas, el
     * topico consultado, y la opción seleccionada sobre que contenido hacer el
     * el cálculo, el umbral y el largo del ranking.
     * @return void
    */
    public void CalcularEuclidiana(Map<String, Integer> Topico,
                                   Map<Integer, List> ResultadosScore,
                                   List<Pagina> ListaPaginas,
                                   List<RelacionPaginas> ListaRelacionPaginas,
                                   String TopicoConsultado,
                                   int OpcionContenido,
                                   double Umbral,
                                   int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {


        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {

            System.out.println("***************************************");
            System.out.println("** CALCULO DE SIMILITUD EUCLIDIANA   **");
            System.out.println("***************************************");

            //Id de la página:
            int id_pagina = 0;
            //Termino del Score:
            String termino;
            //Valor de los Scores:
            double TF_SN = 0;
            double TF_N = 0;
            double TF_S = 0;
            double TFIDF_SN = 0;
            double TFIDF_N = 0;
            double TFIDF_S = 0;
            double TFIDF_O_SN = 0;
            double TFIDF_O_N = 0;
            double TFIDF_O_S = 0;
            double OKAPI = 0;

            //Id_pagina target TF_SN (el de mayor score):
            int id_paginaTF_SN = 0;
            //Id_pagina target TF_N (el de mayor score):
            int id_paginaTF_N = 0;
            //Id_pagina target TF_S (el de mayor score):
            int id_paginaTF_S = 0;
            //Id_pagina target TFIDF_SN (el de mayor score):
            int id_paginaTFIDF_SN = 0;
            //Id_pagina target TFIDF_N (el de mayor score):
            int id_paginaTFIDF_N = 0;
            //Id_pagina target TFIDF_S (el de mayor score):
            int id_paginaTFIDF_S = 0;
            //Id_pagina target TFIDF_O_SN (el de mayor score):
            int id_paginaTFIDF_O_SN = 0;
            //Id_pagina target TFIDF_O_N (el de mayor score):
            int id_paginaTFIDF_O_N = 0;
            //Id_pagina target TFIDF_O_S (el de mayor score):
            int id_paginaTFIDF_O_S = 0;
            //Id_pagina target OKAPI (el de mayor score):
            int id_paginaOKAPI = 0;


            //Indica el numero de páginas a comparar en el  estudio:
            int Npaginas = ListaPaginas.size();
            //Indica el numero de terminos correspondientes al tópico o consulta:
            int Nterminos = Topico.size();


            //Matriz que guarda los valores TF_SN para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTF_SN = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TF_N para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTF_N = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TF_S para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTF_S = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_SN para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_SN = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_N para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_N = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_S para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_S = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_O_SN para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_O_SN = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_O_N para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_O_N = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores TFIDF_O_S para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaTFIDF_O_S = new double[Nterminos][Npaginas];
            //Matriz que guarda los valores OKAPI para las páginas según termino (Termino x Pag)
            double[][] TerminoPaginaOKAPI = new double[Nterminos][Npaginas];


            //Indice i de terminos:
            int i = 0;
            //Indice j de páginas:
            int j = 0;


            ///////////////////////////////////////////////////////////////////////
            //PASO 1: Se obtiene los id_pagina de las páginas con mayor Score para
            //        la consulta (TARGET) (OK)
            ///////////////////////////////////////////////////////////////////////
            id_paginaTF_SN = cscore.ObtenerMejorPaginaTF_SN(Ranking);
            id_paginaTF_N = cscore.ObtenerMejorPaginaTF_N(Ranking);
            id_paginaTF_S = cscore.ObtenerMejorPaginaTF_S(Ranking);
            id_paginaTFIDF_SN = cscore.ObtenerMejorPaginaTFIDF_SN(Ranking);
            id_paginaTFIDF_N = cscore.ObtenerMejorPaginaTFIDF_N(Ranking);
            id_paginaTFIDF_S = cscore.ObtenerMejorPaginaTFIDF_S(Ranking);
            id_paginaTFIDF_O_SN = cscore.ObtenerMejorPaginaTFIDF_O_SN(Ranking);
            id_paginaTFIDF_O_N = cscore.ObtenerMejorPaginaTFIDF_O_N(Ranking);
            id_paginaTFIDF_O_S = cscore.ObtenerMejorPaginaTFIDF_O_S(Ranking);
            id_paginaOKAPI = cscore.ObtenerMejorPaginaOKAPI(Ranking);



            ////////////////////////////////////////////////////
            //PASO 2: Para cada página dentro de Score hacer:
            ////////////////////////////////////////////////////
            Set conjuntoScore = ResultadosScore.entrySet();
            Iterator it = conjuntoScore.iterator();

            while(it.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)it.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtienen los Scores para la página j:
                List<OkapiBM25> ListaScorePagina = new ArrayList();
                ListaScorePagina = (List<OkapiBM25>) me.getValue();

                //Para cada Score por Termino i hacer:
                for (int k=0; k <ListaScorePagina.size(); k++)
                {
                    //Se obtiene el termino del Score:
                    termino = ListaScorePagina.get(k).getTermino();
                    //Se obtiene el TF_SN para la página j:
                    TF_SN = ListaScorePagina.get(k).getTFij_SN();
                    //Se obtiene el TF_N para la página j:
                    TF_N = ListaScorePagina.get(k).getTFij_N();
                    //Se obtiene el TF_S para la página j:
                    TF_S = ListaScorePagina.get(k).getTFij_S();
                    //Se obtiene el TFIDF_SN para la página j:
                    TFIDF_SN = ListaScorePagina.get(k).getTfxIDF_SN();
                    //Se obtiene el TFIDF_N para la página j:
                    TFIDF_N = ListaScorePagina.get(k).getTfxIDF_N();
                    //Se obtiene el TFIDF_S para la página j:
                    TFIDF_S = ListaScorePagina.get(k).getTfxIDF_S();
                    //Se obtiene el TFIDF_O_SN para la página j:
                    TFIDF_O_SN = ListaScorePagina.get(k).getTfxIDF_O_SN();
                    //Se obtiene el TFIDF_O_N para la página j:
                    TFIDF_O_N = ListaScorePagina.get(k).getTfxIDF_O_N();
                    //Se obtiene el TFIDF_O_S para la página j:
                    TFIDF_O_S = ListaScorePagina.get(k).getTfxIDF_O_S();
                    //Se obtiene el OKAPI para la página j:
                    OKAPI = ListaScorePagina.get(k).getOkapi();


                    //Se almacena valor TF_SN para el termino i de la página j
                    TerminoPaginaTF_SN[i][(id_pagina-1)] = TF_SN;
                    //Se almacena valor TF_N para el termino i de la página j
                    TerminoPaginaTF_N[i][(id_pagina-1)] = TF_N;
                    //Se almacena valor TF_S para el termino i de la página j
                    TerminoPaginaTF_S[i][(id_pagina-1)] = TF_S;
                    //Se almacena valor TFIDF_SN para el termino i de la página j
                    TerminoPaginaTFIDF_SN[i][(id_pagina-1)] = TFIDF_SN;
                    //Se almacena valor TFIDF_N para el termino i de la página j
                    TerminoPaginaTFIDF_N[i][(id_pagina-1)] = TFIDF_N;
                    //Se almacena valor TFIDF_S para el termino i de la página j
                    TerminoPaginaTFIDF_S[i][(id_pagina-1)] = TFIDF_S;
                    //Se almacena valor TFIDF_O_SN para el termino i de la página j
                    TerminoPaginaTFIDF_O_SN[i][(id_pagina-1)] = TFIDF_O_SN;
                    //Se almacena valor TFIDF_O_N para el termino i de la página j
                    TerminoPaginaTFIDF_O_N[i][(id_pagina-1)] = TFIDF_O_N;
                    //Se almacena valor TFIDF_O_S para el termino i de la página j
                    TerminoPaginaTFIDF_O_S[i][(id_pagina-1)] = TFIDF_O_S;
                    //Se almacena valor OKAPI para el termino i de la página j
                    TerminoPaginaOKAPI[i][(id_pagina-1)] = OKAPI;


                    //BORRAR ESTO //////////////////////////////////////////////////////
                    System.out.println("+++++++++++++++++++++++++++++++++++++");
                    System.out.println("["+i+","+ (id_pagina-1) +"]"+".-id_pagina: "+ id_pagina);
                    System.out.println("["+i+","+ (id_pagina-1) +"]"+".-termino: "+ termino);
                    System.out.println("["+i+","+ (id_pagina-1) +"]"+".-TerminoPaginaTF_S: "+ TerminoPaginaTF_S[i][(id_pagina-1)]);
                    System.out.println("+++++++++++++++++++++++++++++++++++++");
                    //BORRAR ESTO //////////////////////////////////////////////////////


                    //Se aumenta el contador de la fila (i):
                    i++;


                }//FIN for (Terminos)

                //Se restablece el indice de las filas (Terminos):
                i = 0;
                //Se aumenta el indice de las columnas (Páginas):
                //j++;

            }//FIN while ResultadosScore (Paginas)



            ///////////////////////////////////////////////////////////////////////////
            //PASO 3: Se calcula la similitud euclidiana entre la página TARGET (la de
            //        de mayor pje para el Score) y las páginas OBJETIVO (muestra)
            ///////////////////////////////////////////////////////////////////////////

            //Matriz <Termino x Página> de Score
            Matrix termPag;

            //System.out.println("***************************************");
            //System.out.println("**     VARIANTE 1: SE TF_SN          **");
            //System.out.println("***************************************");

            //Matriz <Termino x Página> de Score para TF_SN:
            termPag = new Matrix(TerminoPaginaTF_SN);
            //Matriz Similitud Euclidiana TF_SN <Target x Páginas Objetivo> :
            Matrix SETF_SN = new Matrix(1, Npaginas);
            //Matriz TARGET TF_SN:
            Matrix targetTF_SN = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTF_SN-1, id_paginaTF_SN-1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTF_SN = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana entre la matriz TARGET,OBJETIVO:
                SETF_SN.set(0, np, SimilaridadEuclidiana(targetTF_SN, objetivoTF_SN));
            }



            //System.out.println("***************************************");
            //System.out.println("**     VARIANTE 2: SE TF_N          **");
            //System.out.println("***************************************");

            //Matriz <Termino x Página> de Score para TF_N:
            termPag = new Matrix(TerminoPaginaTF_N);
            //Matriz Similitud Euclidiana TF_N <Target x Páginas Objetivo> :
            Matrix SETF_N = new Matrix(1, Npaginas);
            //Matriz TARGET TF_N:
            Matrix targetTF_N = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTF_N-1, id_paginaTF_N-1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTF_N = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TF_N entre la matriz TARGET,OBJETIVO:
                SETF_N.set(0, np, SimilaridadEuclidiana(targetTF_N, objetivoTF_N));
            }


            //System.out.println("***************************************");
            //System.out.println("**     VARIANTE 3: SE TF_S          **");
            //System.out.println("***************************************");


            //Matriz <Termino x Página> de Score para TF_S:
            termPag = new Matrix(TerminoPaginaTF_S);
            //Matriz Similitud Euclidiana TF_S <Target x Páginas Objetivo> :
            Matrix SETF_S = new Matrix(1, Npaginas);
            //Matriz TARGET TF_S:
            Matrix targetTF_S = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTF_S - 1, id_paginaTF_S - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTF_S = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TF_S entre la matriz TARGET,OBJETIVO:
                SETF_S.set(0, np, SimilaridadEuclidiana(targetTF_S, objetivoTF_S));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 4: SE TFIDF_SN          **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_SN:
            termPag = new Matrix(TerminoPaginaTFIDF_SN);
            //Matriz Similitud Euclidiana TFIDF_SN <Target x Páginas Objetivo> :
            Matrix SETFIDF_SN = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_SN:
            Matrix targetTFIDF_SN = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_SN-1, id_paginaTFIDF_SN-1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_SN = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TF_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_SN.set(0, np, SimilaridadEuclidiana(targetTFIDF_SN, objetivoTFIDF_SN));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 5: SE TFIDF_N           **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_N:
            termPag = new Matrix(TerminoPaginaTFIDF_N);
            //Matriz Similitud Euclidiana TFIDF_N <Target x Páginas Objetivo> :
            Matrix SETFIDF_N = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_N:
            Matrix targetTFIDF_N = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_N - 1, id_paginaTFIDF_N - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_N = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TF_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_N.set(0, np, SimilaridadEuclidiana(targetTFIDF_N, objetivoTFIDF_N));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 6: SE TFIDF_S           **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_S:
            termPag = new Matrix(TerminoPaginaTFIDF_S);
            //Matriz Similitud Euclidiana TFIDF_S <Target x Páginas Objetivo> :
            Matrix SETFIDF_S = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_S:
            Matrix targetTFIDF_S = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_S - 1, id_paginaTFIDF_S - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_S = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TF_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_S.set(0, np, SimilaridadEuclidiana(targetTFIDF_S, objetivoTFIDF_S));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 7: SE TFIDF_O_SN        **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_O_SN:
            termPag = new Matrix(TerminoPaginaTFIDF_O_SN);
            //Matriz Similitud Euclidiana TFIDF_O_SN <Target x Páginas Objetivo> :
            Matrix SETFIDF_O_SN = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_O_SN:
            Matrix targetTFIDF_O_SN = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_O_SN - 1, id_paginaTFIDF_O_SN - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_O_SN = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TFIDF_O_SN entre la matriz TARGET,OBJETIVO:
                SETFIDF_O_SN.set(0, np, SimilaridadEuclidiana(targetTFIDF_O_SN, objetivoTFIDF_O_SN));
            }
            

            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 8: SE TFIDF_O_N         **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_O_N:
            termPag = new Matrix(TerminoPaginaTFIDF_O_N);
            //Matriz Similitud Euclidiana TFIDF_O_SN <Target x Páginas Objetivo> :
            Matrix SETFIDF_O_N = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_O_SN:
            Matrix targetTFIDF_O_N = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_O_N - 1, id_paginaTFIDF_O_N - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_O_N = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TFIDF_O_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_O_N.set(0, np, SimilaridadEuclidiana(targetTFIDF_O_N, objetivoTFIDF_O_N));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 9: SE TFIDF_O_S         **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para TFIDF_O_S:
            termPag = new Matrix(TerminoPaginaTFIDF_O_S);
            //Matriz Similitud Euclidiana TFIDF_O_S <Target x Páginas Objetivo> :
            Matrix SETFIDF_O_S = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_O_S:
            Matrix targetTFIDF_O_S = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaTFIDF_O_S - 1, id_paginaTFIDF_O_S - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoTFIDF_O_S = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana TFIDF_O_S entre la matriz TARGET,OBJETIVO:
                SETFIDF_O_S.set(0, np, SimilaridadEuclidiana(targetTFIDF_O_S, objetivoTFIDF_O_S));
            }


            //System.out.println("******************************************");
            //System.out.println("**     VARIANTE 10: SE OKAPI            **");
            //System.out.println("******************************************");

            //Matriz <Termino x Página> de Score para OKAPI:
            termPag = new Matrix(TerminoPaginaOKAPI);
            //Matriz Similitud Euclidiana OKAPI <Target x Páginas Objetivo> :
            Matrix SEOKAPI = new Matrix(1, Npaginas);
            //Matriz TARGET TFIDF_O_S:
            Matrix targetOKAPI = termPag.getMatrix( 0, termPag.getRowDimension() - 1, id_paginaOKAPI - 1, id_paginaOKAPI - 1);

            //Para el numero de páginas (np) hacer:
            for (int np = 0; np < Npaginas; np++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix objetivoOKAPI = termPag.getMatrix(0, termPag.getRowDimension() - 1, np, np);
                //Se calcula la similud Euclidiana OKAPI entre la matriz TARGET,OBJETIVO:
                SEOKAPI.set(0, np, SimilaridadEuclidiana(targetOKAPI, objetivoOKAPI));
            }


            ////////////////////////////////////////////
            //PASO 3: Se guardan los calculos en la BD
            ////////////////////////////////////////////


            //Variable de clase:
            Euclidiana euclidiana;
            //url test:
            String url_test = null;
            //url objetivo:
            String url_objetivo = null;
            //id_pagina objetivo:
            int id_pagina_objetivo;
            //ArrayList resultadosPaginaSC:
            List<Euclidiana> resultadosPaginaSE = null;


            // (1) Map ResultadosSETF_SN:
            Map<Integer, List> ResultadosSETF_SN;
            // (2) Map ResultadosSETF_N:
            Map<Integer, List> ResultadosSETF_N;
            // (3) Map ResultadosSETF_S:
            Map<Integer, List> ResultadosSETF_S;
            // (4) Map ResultadosSETFIDF_SN:
            Map<Integer, List> ResultadosSETFIDF_SN;
            // (5) Map ResultadosSETFIDF_N:
            Map<Integer, List> ResultadosSETFIDF_N;
            // (6) Map ResultadosSETFIDF_S:
            Map<Integer, List> ResultadosSETFIDF_S;
            // (7) Map ResultadosSETFIDF_O_SN:
            Map<Integer, List> ResultadosSETFIDF_O_SN;
            // (8) Map ResultadosSETFIDF_O_N:
            Map<Integer, List> ResultadosSETFIDF_O_N;
            // (9) Map ResultadosSETFIDF_O_S:
            Map<Integer, List> ResultadosSETFIDF_O_S;
            // (10) Map ResultadosSEOKAPI:
            Map<Integer, List> ResultadosSEOKAPI;



            ////////////////////////////////////////////
            // (1) Para Similitud euclidiana con SETF_SN:
            ////////////////////////////////////////////
            ResultadosSETF_SN = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTF_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTF_SN)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETF_SN.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETF_SN.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETF_SN



            ////////////////////////////////////////////
            // (2) Para Similitud euclidiana con SCTF_N:
            ////////////////////////////////////////////
            ResultadosSETF_N = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTF_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTF_N)
                    {
                        url_objetivo= ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETF_N.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETF_N.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETF_N



            ////////////////////////////////////////////
            // (3) Para Similitud euclidiana con SETF_S:
            ////////////////////////////////////////////
            ResultadosSETF_S = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTF_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTF_S)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETF_S.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETF_S.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETF_S



            ////////////////////////////////////////////
            // (4) Para Similitud euclidiana con SETFIDF_SN:
            ////////////////////////////////////////////
            ResultadosSETFIDF_SN = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_SN)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test= ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud coseno para SETF_SN:
                euclidiana.setValor_se(SETFIDF_SN.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETFIDF_SN.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_SN



            ////////////////////////////////////////////
            // (5) Para Similitud euclidiana con SETFIDF_N:
            ////////////////////////////////////////////
            ResultadosSETFIDF_N = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_N)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud coseno para SCTF_SN:
                euclidiana.setValor_se(SETFIDF_N.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN:
                ResultadosSETFIDF_N.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_N



            ////////////////////////////////////////////
            // (6) Para Similitud Coseno con SETFIDF_S:
            ////////////////////////////////////////////
            ResultadosSETFIDF_S = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_S)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud coseno para SETF_SN:
                euclidiana.setValor_se(SETFIDF_S.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETFIDF_S.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_S



            ////////////////////////////////////////////////
            // (7) Para Similitud euclidiana con SETFIDF_O_SN:
            ////////////////////////////////////////////////
            ResultadosSETFIDF_O_SN = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_O_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_O_SN)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud coseno para SETF_SN:
                euclidiana.setValor_se(SETFIDF_O_SN.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETFIDF_O_SN.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_O_SN



            ////////////////////////////////////////////////
            // (8) Para Similitud euclidiana con SETFIDF_O_N:
            ////////////////////////////////////////////////
            ResultadosSETFIDF_O_N = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_O_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_O_N)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETFIDF_O_N.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN:
                ResultadosSETFIDF_O_N.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_O_N



            ////////////////////////////////////////////////
            // (9) Para Similitud euclidiana con SETFIDF_O_S:
            ////////////////////////////////////////////////
            ResultadosSETFIDF_O_S = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaTFIDF_O_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina target:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaTFIDF_O_S)
                    {
                        url_objetivo= ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETFIDF_O_S.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN:
                ResultadosSETFIDF_O_S.put(id_pagina, resultadosPaginaSE);

            }//FIN for SETFIDF_O_S



            ////////////////////////////////////////////////
            // (10) Para Similitud euclidiana con SEOKAPI:
            ////////////////////////////////////////////////
            ResultadosSEOKAPI = new HashMap();

            for (int np = 0; np < Npaginas; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_pagina = np+1;
                euclidiana.setId_pagina(id_pagina);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_paginaOKAPI);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaPaginas.size(); k++)
                {
                    //Si el id_pagina se corresponde al del id_pagina objetivo:
                    if (ListaPaginas.get(k).getId_pagina() == id_paginaOKAPI)
                    {
                        url_objetivo = ListaPaginas.get(k).getUrl();
                    }
                    //Si el id_pagina se corresponde al del id_pagina test:
                    if (ListaPaginas.get(k).getId_pagina() == id_pagina)
                    {
                        url_test = ListaPaginas.get(k).getUrl();
                    }
                }
                euclidiana.setUrl_test(url_test);
                euclidiana.setUrl_objetivo(url_objetivo);

                //Se setea el valor de la similitud coseno para SETF_SN:
                euclidiana.setValor_se(SEOKAPI.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN:
                ResultadosSEOKAPI.put(id_pagina, resultadosPaginaSE);

            }//FIN for SCOKAPI


            //////////////////////////////////////////
            //PASO 4: Se guardan los datos en la BD:
            //////////////////////////////////////////
            sebd.GuardarSimilitudEuclidiana(ResultadosSETF_SN, ResultadosSETF_N, ResultadosSETF_S,
                                            ResultadosSETFIDF_SN, ResultadosSETFIDF_N, ResultadosSETFIDF_S,
                                            ResultadosSETFIDF_O_SN, ResultadosSETFIDF_O_N, ResultadosSETFIDF_O_S,
                                            ResultadosSEOKAPI, TopicoConsultado, Umbral, Ranking);


            //////////////////////////////////////////////////
            //PASO 5: Se calcula el ranking de las páginas
            //////////////////////////////////////////////////
            sebd.RankearMedicionSE(Ranking, TopicoConsultado);
            
        }//FIN IF BODY


        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {

            System.out.println("****************************************************");
            System.out.println("** CALCULO DE SIMILITUD EUCLIDIANA SURROUND TEXT  **");
            System.out.println("****************************************************");

            //Id relacion pagina:
            int id_relacion_pag = 0;
            //Termino del Score:
            String termino;
            //Valor de los Scores:
            double TF_SN = 0;
            double TF_N = 0;
            double TF_S = 0;
            double TFIDF_SN = 0;
            double TFIDF_N = 0;
            double TFIDF_S = 0;
            double TFIDF_O_SN = 0;
            double TFIDF_O_N = 0;
            double TFIDF_O_S = 0;
            double OKAPI = 0;

            //Id_ST objetivo TF_SN (el de mayor score):
            int id_ST_TF_SN = 0;
            //Id_ST objetivo TF_N (el de mayor score):
            int id_ST_TF_N = 0;
            //Id_ST objetivo TF_S (el de mayor score):
            int id_ST_TF_S = 0;
            //Id_ST objetivo TFIDF_SN (el de mayor score):
            int id_ST_TFIDF_SN = 0;
            //Id_ST objetivo TFIDF_N (el de mayor score):
            int id_ST_TFIDF_N = 0;
            //Id_ST objetivo TFIDF_S (el de mayor score):
            int id_ST_TFIDF_S = 0;
            //Id_ST objetivo TFIDF_O_SN (el de mayor score):
            int id_ST_TFIDF_O_SN = 0;
            //Id_ST objetivo TFIDF_O_N (el de mayor score):
            int id_ST_TFIDF_O_N = 0;
            //Id_ST objetivo TFIDF_O_S (el de mayor score):
            int id_ST_TFIDF_O_S = 0;
            //Id_ST objetivo OKAPI (el de mayor score):
            int id_ST_OKAPI = 0;

            //Indica el numero de ST's a comparar en el  estudio:
            int NSText = ListaRelacionPaginas.size();
            //Indica el numero de terminos correspondientes al tópico o consulta:
            int Nterminos = Topico.size();

            //Matriz que guarda los valores TF_SN para los ST según termino (Termino x ST)
            double[][] TerminoST_TF_SN = new double[Nterminos][NSText];
            //Matriz que guarda los valores TF_N para los ST según termino (Termino x ST)
            double[][] TerminoST_TF_N = new double[Nterminos][NSText];
            //Matriz que guarda los valores TF_S para los ST según termino (Termino x ST)
            double[][] TerminoST_TF_S = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_SN para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_SN = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_N para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_N = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_S para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_S = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_O_SN para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_O_SN = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_O_N para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_O_N = new double[Nterminos][NSText];
            //Matriz que guarda los valores TFIDF_O_S para los ST según termino (Termino x ST)
            double[][] TerminoST_TFIDF_O_S = new double[Nterminos][NSText];
            //Matriz que guarda los valores OKAPI para los ST según termino (Termino x ST)
            double[][] TerminoST_OKAPI = new double[Nterminos][NSText];


            //Indice i de terminos:
            int i = 0;
            //Indice j de páginas:
            int j = 0;


            ///////////////////////////////////////////////////////////////////////
            //PASO 1: Se obtiene los id_pagina de las páginas con mayor Score para
            //        la consulta (TARGET) (OK)
            ///////////////////////////////////////////////////////////////////////
            id_ST_TF_SN = cscore.ObtenerMejorST_TF_SN(Ranking);
            id_ST_TF_N = cscore.ObtenerMejorST_TF_N(Ranking);
            id_ST_TF_S = cscore.ObtenerMejorST_TF_S(Ranking);
            id_ST_TFIDF_SN = cscore.ObtenerMejorST_TFIDF_SN(Ranking);
            id_ST_TFIDF_N = cscore.ObtenerMejorST_TFIDF_N(Ranking);
            id_ST_TFIDF_S = cscore.ObtenerMejorST_TFIDF_S(Ranking);
            id_ST_TFIDF_O_SN = cscore.ObtenerMejorST_TFIDF_O_SN(Ranking);
            id_ST_TFIDF_O_N = cscore.ObtenerMejorST_TFIDF_O_N(Ranking);
            id_ST_TFIDF_O_S = cscore.ObtenerMejorST_TFIDF_O_S(Ranking);
            id_ST_OKAPI = cscore.ObtenerMejorST_OKAPI(Ranking);

            ////////////////////////////////////////////////////
            //PASO 2: Para cada ST dentro de Score hacer:
            ////////////////////////////////////////////////////
            Set conjuntoScore = ResultadosScore.entrySet();
            Iterator it = conjuntoScore.iterator();

            while(it.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)it.next();
                //Se obtiene el id_relacion_pag:
                id_relacion_pag = (Integer) me.getKey();
                //Se obtienen los Scores para la página j:
                List<OkapiBM25> ListaScoreST = new ArrayList();
                ListaScoreST = (List<OkapiBM25>) me.getValue();

                //Para cada Score por Termino i hacer:
                for (int k=0; k <ListaScoreST.size(); k++)
                {
                    //Se obtiene el termino del Score:
                    termino = ListaScoreST.get(k).getTermino();
                    //Se obtiene el TF_SN para el ST j:
                    TF_SN = ListaScoreST.get(k).getTFij_SN();
                    //Se obtiene el TF_N para la ST j:
                    TF_N = ListaScoreST.get(k).getTFij_N();
                    //Se obtiene el TF_S para la ST j:
                    TF_S = ListaScoreST.get(k).getTFij_S();
                    //Se obtiene el TFIDF_SN para la ST j:
                    TFIDF_SN = ListaScoreST.get(k).getTfxIDF_SN();
                    //Se obtiene el TFIDF_N para la ST j:
                    TFIDF_N = ListaScoreST.get(k).getTfxIDF_N();
                    //Se obtiene el TFIDF_S para la ST j:
                    TFIDF_S = ListaScoreST.get(k).getTfxIDF_S();
                    //Se obtiene el TFIDF_O_SN para la ST j:
                    TFIDF_O_SN = ListaScoreST.get(k).getTfxIDF_O_SN();
                    //Se obtiene el TFIDF_O_N para la ST j:
                    TFIDF_O_N = ListaScoreST.get(k).getTfxIDF_O_N();
                    //Se obtiene el TFIDF_O_S para la ST j:
                    TFIDF_O_S = ListaScoreST.get(k).getTfxIDF_O_S();
                    //Se obtiene el OKAPI para la ST j:
                    OKAPI = ListaScoreST.get(k).getOkapi();


                    //Se almacena valor TF_SN para el termino i del ST j
                    TerminoST_TF_SN[i][(id_relacion_pag-1)] = TF_SN;
                    //Se almacena valor TF_N para el termino i de la ST j
                    TerminoST_TF_N[i][(id_relacion_pag-1)] = TF_N;
                    //Se almacena valor TF_S para el termino i de la ST j
                    TerminoST_TF_S[i][(id_relacion_pag-1)] = TF_S;
                    //Se almacena valor TFIDF_SN para el termino i de la ST j
                    TerminoST_TFIDF_SN[i][(id_relacion_pag-1)] = TFIDF_SN;
                    //Se almacena valor TFIDF_N para el termino i de la ST j
                    TerminoST_TFIDF_N[i][(id_relacion_pag-1)] = TFIDF_N;
                    //Se almacena valor TFIDF_S para el termino i de la ST j
                    TerminoST_TFIDF_S[i][(id_relacion_pag-1)] = TFIDF_S;
                    //Se almacena valor TFIDF_O_SN para el termino i de la ST j
                    TerminoST_TFIDF_O_SN[i][(id_relacion_pag-1)] = TFIDF_O_SN;
                    //Se almacena valor TFIDF_O_N para el termino i de la ST j
                    TerminoST_TFIDF_O_N[i][(id_relacion_pag-1)] = TFIDF_O_N;
                    //Se almacena valor TFIDF_O_S para el termino i de la ST j
                    TerminoST_TFIDF_O_S[i][(id_relacion_pag-1)] = TFIDF_O_S;
                    //Se almacena valor OKAPI para el termino i de la ST j
                    TerminoST_OKAPI[i][(id_relacion_pag-1)] = OKAPI;

                    //Se aumenta el contador de la fila (i):
                    i++;


                }//FIN for (Terminos)

                //Se restablece el indice de las filas (Terminos):
                i = 0;
                //Se aumenta el indice de las columnas (Páginas):
                //j++;

            }//FIN while ResultadosScore (ST)


            ///////////////////////////////////////////////////////////////////////////
            //PASO 3: Se calcula la similitud euclidiana entre el ST TARGET (la de
            //        de mayor pje para el Score) y el ST de prueba (muestra)
            ///////////////////////////////////////////////////////////////////////////

            //Matriz <Termino x ST> de Score
            Matrix termxST;

            //System.out.println("******************************************************");
            //System.out.println("**     VARIANTE 1: SE TF_SN (SURROUND TEXT)         **");
            //System.out.println("******************************************************");

            //Matriz <Termino x ST> de Score para TF_SN:
            termxST = new Matrix(TerminoST_TF_SN);
            //Matriz Similitud Euclidiana TF_SN <Target x Páginas MUESTRA> :
            Matrix SETF_SN_ST = new Matrix(1, NSText);
            //Matriz TARGET TF_SN:
            Matrix targetTF_SN = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TF_SN-1, id_ST_TF_SN-1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x Pagina> MUESTRA:
                Matrix muestraTF_SN = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno entre la matriz TARGET,OBJETIVO:
                SETF_SN_ST.set(0, num_st, SimilaridadEuclidiana(targetTF_SN, muestraTF_SN));
            }



            //System.out.println("*****************************************************");
            //System.out.println("**     VARIANTE 2: SE TF_N (SURROUND TEXT)         **");
            //System.out.println("*****************************************************");

            //Matriz <Termino x ST> de Score para TF_N:
            termxST = new Matrix(TerminoST_TF_N);
            //Matriz Similitud Coseno TF_N <Target x Páginas MUESTRA> :
            Matrix SETF_N_ST = new Matrix(1, NSText);
            //Matriz TARGET TF_N:
            Matrix targetTF_N = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TF_N-1, id_ST_TF_N-1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix muestraTF_N = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TF_N entre la matriz TARGET,OBJETIVO:
                SETF_N_ST.set(0, num_st, SimilaridadEuclidiana(targetTF_N, muestraTF_N));
            }


            //System.out.println("*****************************************************");
            //System.out.println("**     VARIANTE 3: SE TF_S (SURROUND TEXT)         **");
            //System.out.println("*****************************************************");


            //Matriz <Termino x ST> de Score para TF_S:
            termxST = new Matrix(TerminoST_TF_S);
            //Matriz Similitud Coseno TF_S <Target x Páginas MUESTRA> :
            Matrix SETF_S_ST = new Matrix(1, NSText);
            //Matriz TARGET TF_S:
            Matrix targetTF_S = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TF_S - 1, id_ST_TF_S - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> MUESTRA:
                Matrix muestraTF_S = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TF_S entre la matriz TARGET,MUESTRA:
                SETF_S_ST.set(0, num_st, SimilaridadEuclidiana(targetTF_S, muestraTF_S));
            }



            //System.out.println("*********************************************************");
            //System.out.println("**     VARIANTE 4: SE TFIDF_SN (SURROUND TEXT)         **");
            //System.out.println("*********************************************************");


            //Matriz <Termino x ST> de Score para  TFIDF_SN:
            termxST = new Matrix(TerminoST_TFIDF_SN);
            //Matriz Similitud Coseno TFIDF_SN <Target x Páginas MUESTRA> :
            Matrix SETFIDF_SN_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_SN:
            Matrix targetTFIDF_SN = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_SN-1, id_ST_TFIDF_SN-1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> MUESTRA:
                Matrix muestraTFIDF_SN = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TF_N entre la matriz TARGET,MUESTRA:
                SETFIDF_SN_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_SN, muestraTFIDF_SN));
            }



            //System.out.println("********************************************************");
            //System.out.println("**     VARIANTE 5: SC TFIDF_N (SURROUND TEXT)         **");
            //System.out.println("********************************************************");

            //Matriz <Termino x ST> de Score para TFIDF_N:
            termxST = new Matrix(TerminoST_TFIDF_N);
            //Matriz Similitud Coseno TFIDF_N <Target x Páginas MUESTRA> :
            Matrix SETFIDF_N_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_N:
            Matrix targetTFIDF_N = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_N - 1, id_ST_TFIDF_N - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> MUESTRA:
                Matrix muestraTFIDF_N = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TF_N entre la matriz TARGET,MUESTRA:
                SETFIDF_N_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_N, muestraTFIDF_N));
            }




            //System.out.println("********************************************************");
            //System.out.println("**     VARIANTE 6: SC TFIDF_S (SURROUND TEXT)         **");
            //System.out.println("********************************************************");

            //Matriz <Termino x ST> de Score para TFIDF_S:
            termxST = new Matrix(TerminoST_TFIDF_S);
            //Matriz Similitud Coseno TFIDF_S <Target x Páginas MUESTRA> :
            Matrix SETFIDF_S_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_S:
            Matrix targetTFIDF_S = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_S - 1, id_ST_TFIDF_S - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> MUESTRA:
                Matrix muestraTFIDF_S = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TF_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_S_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_S, muestraTFIDF_S));
            }




            //System.out.println("***********************************************************");
            //System.out.println("**     VARIANTE 7: SC TFIDF_O_SN (SURROUND TEXT)         **");
            //System.out.println("***********************************************************");

            //Matriz <Termino x ST> de Score para TFIDF_O_SN:
            termxST = new Matrix(TerminoST_TFIDF_O_SN);
            //Matriz Similitud Coseno TFIDF_O_SN <Target x Páginas MUESTRA> :
            Matrix SETFIDF_O_SN_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_O_SN:
            Matrix targetTFIDF_O_SN = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_O_SN - 1, id_ST_TFIDF_O_SN - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> muestra:
                Matrix muestraTFIDF_O_SN = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TFIDF_O_SN entre la matriz TARGET,MUESTRA:
                SETFIDF_O_SN_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_O_SN, muestraTFIDF_O_SN));
            }



            //System.out.println("**********************************************************");
            //System.out.println("**     VARIANTE 8: SC TFIDF_O_N (SURROUND TEXT)         **");
            //System.out.println("**********************************************************");

            //Matriz <Termino x ST> de Score para TFIDF_O_N:
            termxST = new Matrix(TerminoST_TFIDF_O_N);
            //Matriz Similitud Coseno TFIDF_O_SN <Target x Páginas MUESTRA> :
            Matrix SETFIDF_O_N_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_O_SN:
            Matrix targetTFIDF_O_N = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_O_N - 1, id_ST_TFIDF_O_N - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x Pagina> objetivo:
                Matrix muestraTFIDF_O_N = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TFIDF_O_N entre la matriz TARGET,OBJETIVO:
                SETFIDF_O_N_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_O_N, muestraTFIDF_O_N));
            }




            //System.out.println("**********************************************************");
            //System.out.println("**     VARIANTE 9: SC TFIDF_O_S (SURROUND TEXT)         **");
            //System.out.println("**********************************************************");

            //Matriz <Termino x ST> de Score para TFIDF_O_S:
            termxST = new Matrix(TerminoST_TFIDF_O_S);
            //Matriz Similitud Coseno TFIDF_O_S <Target x Páginas MUESTRA> :
            Matrix SETFIDF_O_S_ST = new Matrix(1, NSText);
            //Matriz TARGET TFIDF_O_S:
            Matrix targetTFIDF_O_S = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_TFIDF_O_S - 1, id_ST_TFIDF_O_S - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> Muestra:
                Matrix muestraTFIDF_O_S = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno TFIDF_O_S entre la matriz TARGET,MUESTRA:
                SETFIDF_O_S_ST.set(0, num_st, SimilaridadEuclidiana(targetTFIDF_O_S, muestraTFIDF_O_S));
            }



            //System.out.println("*******************************************************");
            //System.out.println("**     VARIANTE 10: SC OKAPI (SURROUND TEXT)         **");
            //System.out.println("*******************************************************");

            //Matriz <Termino x ST> de Score para OKAPI:
            termxST = new Matrix(TerminoST_OKAPI);
            //Matriz Similitud Coseno OKAPI <Target x Páginas Muestra> :
            Matrix SEOKAPI_ST = new Matrix(1, NSText);
            //Matriz TARGET OKAPI:
            Matrix targetOKAPI = termxST.getMatrix( 0, termxST.getRowDimension() - 1, id_ST_OKAPI - 1, id_ST_OKAPI - 1);

            //Para el numero de ST (num_st) hacer:
            for (int num_st = 0; num_st < NSText; num_st++)
            {
                //Matriz <Termino x ST> muestra:
                Matrix muestraOKAPI = termxST.getMatrix(0, termxST.getRowDimension() - 1, num_st, num_st);
                //Se calcula la similud coseno OKAPI entre la matriz TARGET,MUESTRA:
                SEOKAPI_ST.set(0, num_st, SimilaridadEuclidiana(targetOKAPI, muestraOKAPI));
            }


            ////////////////////////////////////////////
            //PASO 3: Se guardan los calculos en la BD
            ////////////////////////////////////////////

            //Variable de clase:
            Euclidiana euclidiana;
            //url test:
            String url_test = null;
            //url objetivo:
            String url_objetivo = null;
            //id_pagina objetivo:
            int id_pagina_objetivo;
            //ArrayList resultadosPaginaSC:
            List<Euclidiana> resultadosPaginaSE = null;

            // (1) Map ResultadosSETF_SN_ST:
            Map<Integer, List> ResultadosSETF_SN_ST;
            // (2) Map ResultadosSETF_N_ST:
            Map<Integer, List> ResultadosSETF_N_ST;
            // (3) Map ResultadosSETF_S_ST:
            Map<Integer, List> ResultadosSETF_S_ST;
            // (4) Map ResultadosSETFIDF_SN_ST:
            Map<Integer, List> ResultadosSETFIDF_SN_ST;
            // (5) Map ResultadosSETFIDF_N_ST:
            Map<Integer, List> ResultadosSETFIDF_N_ST;
            // (6) Map ResultadosSETFIDF_S_ST:
            Map<Integer, List> ResultadosSETFIDF_S_ST;
            // (7) Map ResultadosSETFIDF_O_SN_ST:
            Map<Integer, List> ResultadosSETFIDF_O_SN_ST;
            // (8) Map ResultadosSETFIDF_O_N_ST:
            Map<Integer, List> ResultadosSETFIDF_O_N_ST;
            // (9) Map ResultadosSETFIDF_O_S_ST:
            Map<Integer, List> ResultadosSETFIDF_O_S_ST;
            // (10) Map ResultadosSEOKAPI_ST:
            Map<Integer, List> ResultadosSEOKAPI_ST;

            
            ////////////////////////////////////////////////////////
            // (1) Para Similitud euclidiana con SETF_SN_ST:
            ////////////////////////////////////////////////////////
            ResultadosSETF_SN_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_relacion_pag:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página test y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se gaurdan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN:
                euclidiana.setValor_se(SETF_SN_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETF_SN_ST.put(id_relacion_pag, (ArrayList) resultadosPaginaSE);

            }//FIN for SETF_SN_ST



            //////////////////////////////////////////////////////
            // (2) Para Similitud euclidiana con SCTF_N_ST:
            //////////////////////////////////////////////////////
            ResultadosSETF_N_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TF_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN_ST:
                euclidiana.setValor_se(SETF_N_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN:
                ResultadosSETF_N_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETF_N_ST



            //////////////////////////////////////////////////////////
            // (3) Para Similitud euclidiana con  SCTF_S_ST:
            //////////////////////////////////////////////////////////
            ResultadosSETF_S_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TF_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN_ST:
                euclidiana.setValor_se(SETF_S_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN_ST:
                ResultadosSETF_S_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETF_S_ST



            ////////////////////////////////////////////////////////////
            // (4) Para Similitud euclidiana con SCTFIDF_SN_ST:
            ////////////////////////////////////////////////////////////
            ResultadosSETFIDF_SN_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud coseno para SETF_SN_ST:
                euclidiana.setValor_se(SETFIDF_SN_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN_ST:
                ResultadosSETFIDF_SN_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_SN_ST



            ////////////////////////////////////////////////////////////
            // (5) Para Similitud euclidiana con SCTFIDF_N_ST:
            ////////////////////////////////////////////////////////////
            ResultadosSETFIDF_N_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud coseno para SCTF_SN_ST:
                euclidiana.setValor_se(SETFIDF_N_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN_ST:
                ResultadosSETFIDF_N_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_N_ST



            ///////////////////////////////////////////////////////
            // (6) Para Similitud Coseno con SCTFIDF_S_ST:
            ///////////////////////////////////////////////////////
            ResultadosSETFIDF_S_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud coseno para SETF_SN_ST:
                euclidiana.setValor_se(SETFIDF_S_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN_ST:
                ResultadosSETFIDF_S_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_S_ST



            //////////////////////////////////////////////////////////////
            // (7) Para Similitud euclidiana con SETFIDF_O_SN_ST:
            //////////////////////////////////////////////////////////////
            ResultadosSETFIDF_O_SN_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_O_SN);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud coseno para SETF_SN_ST:
                euclidiana.setValor_se(SETFIDF_O_SN_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SETF_SN_ST:
                ResultadosSETFIDF_O_SN_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_O_SN_ST



            //////////////////////////////////////////////////////////
            // (8) Para Similitud euclidiana con SETFIDF_O_N_ST:
            //////////////////////////////////////////////////////////
            ResultadosSETFIDF_O_N_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_O_N);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN_ST:
                euclidiana.setValor_se(SETFIDF_O_N_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN_ST:
                ResultadosSETFIDF_O_N_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_O_N_ST



            ////////////////////////////////////////////////////////////////
            // (9) Para Similitud euclidiana con SETFIDF_O_S_ST:
            ////////////////////////////////////////////////////////////////
            ResultadosSETFIDF_O_S_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_TFIDF_O_S);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud euclidiana para SETF_SN_ST:
                euclidiana.setValor_se(SETFIDF_O_S_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN_ST:
                ResultadosSETFIDF_O_S_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SETFIDF_O_S_ST



            /////////////////////////////////////////////////////////
            // (10) Para Similitud euclidiana con SEOKAPI_ST:
            /////////////////////////////////////////////////////////
            ResultadosSEOKAPI_ST = new HashMap();

            for (int np = 0; np < NSText; np++)
            {
                //Se instancia la estructua SE:
                euclidiana = new Euclidiana();
                //Se setean id_pagina test:
                id_relacion_pag = np+1;
                euclidiana.setId_relacion_pag(id_relacion_pag);
                //Se setean id_pagina objetivo:
                euclidiana.setId_pagina_objetivo(id_ST_OKAPI);
                //Se setean el termino:
                euclidiana.setTermino(TopicoConsultado);
                //Se setean la url de la página target y objetivo:
                for (int k=0; k<ListaRelacionPaginas.size(); k++)
                {
                    //Si es igual al id_relacion_pag:
                    if (ListaRelacionPaginas.get(k).getId_relacion_pagina() == id_relacion_pag)
                    {
                        //Se extrae el id_pagina test que es igual a la pagina
                        //destino dentro de relacion_pagina (id_pagina):
                        int id_pag_destino = ListaRelacionPaginas.get(k).getId_pagina_destino();

                        //Se busca en el listado pagina las url correspondientes
                        //a url test y url objetivo
                        for (int h=0; h<ListaPaginas.size(); h++)
                        {
                            //Si el id_pagina se corresponde al del id_pagina objetivo:
                            if (ListaPaginas.get(h).getId_pagina() == id_ST_TF_SN)
                            {
                                url_objetivo = ListaPaginas.get(h).getUrl();
                            }
                            //Si el id_pagina se corresponde al del id_pagina test:
                            if (ListaPaginas.get(h).getId_pagina() == id_pag_destino)
                            {
                                url_test = ListaPaginas.get(h).getUrl();
                            }
                        }
                    }
                }

                //Se guardan las URL test y objetivo en la List:
                euclidiana.setUrl_objetivo(url_objetivo);
                euclidiana.setUrl_test(url_test);

                //Se setea el valor de la similitud coseno para SETF_SN_ST:
                euclidiana.setValor_se(SEOKAPI_ST.get(0, np));

                //Se guarda en el List el resultado para esta página objetivo:
                resultadosPaginaSE = new ArrayList();
                resultadosPaginaSE.add(euclidiana);

                //Se guardan los resultados de las paginas para SCTF_SN_ST:
                ResultadosSEOKAPI_ST.put(id_relacion_pag, resultadosPaginaSE);

            }//FIN for SEOKAPI_ST


            //////////////////////////////////////////
            //PASO 4: Se guardan los datos en la BD:
            //////////////////////////////////////////
            sebd.GuardarSimilitudEuclidiana_ST(ResultadosSETF_SN_ST, ResultadosSETF_N_ST, ResultadosSETF_S_ST,
                                               ResultadosSETFIDF_SN_ST, ResultadosSETFIDF_N_ST, ResultadosSETFIDF_S_ST,
                                               ResultadosSETFIDF_O_SN_ST, ResultadosSETFIDF_O_N_ST, ResultadosSETFIDF_O_S_ST,
                                               ResultadosSEOKAPI_ST, TopicoConsultado, Umbral, Ranking);


            //////////////////////////////////////////////////
            //PASO 5: Se calcula el ranking de las páginas
            //////////////////////////////////////////////////
            sebd.RankearMedicionSE_ST(Ranking, TopicoConsultado);
        }//FIN IF SURROUND TEXT


    }//FIN CalcularEuclidiana

}//FIN CLASE Euclidiana